home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / arm / include / asm / memory.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  8.5 KB  |  313 lines
  1. /*
  2.  *  arch/arm/include/asm/memory.h
  3.  *
  4.  *  Copyright (C) 2000-2002 Russell King
  5.  *  modification for nommu, Hyok S. Choi, 2004
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 2 as
  9.  * published by the Free Software Foundation.
  10.  *
  11.  *  Note: this file should not be included by non-asm/.h files
  12.  */
  13. #ifndef __ASM_ARM_MEMORY_H
  14. #define __ASM_ARM_MEMORY_H
  15.  
  16. #include <linux/compiler.h>
  17. #include <linux/const.h>
  18. #include <mach/memory.h>
  19. #include <asm/sizes.h>
  20.  
  21. /*
  22.  * Allow for constants defined here to be used from assembly code
  23.  * by prepending the UL suffix only with actual C code compilation.
  24.  */
  25. #define UL(x) _AC(x, UL)
  26.  
  27. #ifdef CONFIG_MMU
  28.  
  29. /*
  30.  * PAGE_OFFSET - the virtual address of the start of the kernel image
  31.  * TASK_SIZE - the maximum size of a user space task.
  32.  * TASK_UNMAPPED_BASE - the lower boundary of the mmap VM area
  33.  */
  34. #define PAGE_OFFSET        UL(CONFIG_PAGE_OFFSET)
  35. #define TASK_SIZE        (UL(CONFIG_PAGE_OFFSET) - UL(0x01000000))
  36. #define TASK_UNMAPPED_BASE    (UL(CONFIG_PAGE_OFFSET) / 3)
  37.  
  38. /*
  39.  * The maximum size of a 26-bit user space task.
  40.  */
  41. #define TASK_SIZE_26        UL(0x04000000)
  42.  
  43. /*
  44.  * The module space lives between the addresses given by TASK_SIZE
  45.  * and PAGE_OFFSET - it must be within 32MB of the kernel text.
  46.  */
  47. #define MODULES_END        (PAGE_OFFSET)
  48. #define MODULES_VADDR        (MODULES_END - 16*1048576)
  49.  
  50. #if TASK_SIZE > MODULES_VADDR
  51. #error Top of user space clashes with start of module space
  52. #endif
  53.  
  54. /*
  55.  * The XIP kernel gets mapped at the bottom of the module vm area.
  56.  * Since we use sections to map it, this macro replaces the physical address
  57.  * with its virtual address while keeping offset from the base section.
  58.  */
  59. #define XIP_VIRT_ADDR(physaddr)  (MODULES_VADDR + ((physaddr) & 0x000fffff))
  60.  
  61. /*
  62.  * Allow 16MB-aligned ioremap pages
  63.  */
  64. #define IOREMAP_MAX_ORDER    24
  65.  
  66. #else /* CONFIG_MMU */
  67.  
  68. /*
  69.  * The limitation of user task size can grow up to the end of free ram region.
  70.  * It is difficult to define and perhaps will never meet the original meaning
  71.  * of this define that was meant to.
  72.  * Fortunately, there is no reference for this in noMMU mode, for now.
  73.  */
  74. #ifndef TASK_SIZE
  75. #define TASK_SIZE        (CONFIG_DRAM_SIZE)
  76. #endif
  77.  
  78. #ifndef TASK_UNMAPPED_BASE
  79. #define TASK_UNMAPPED_BASE    UL(0x00000000)
  80. #endif
  81.  
  82. #ifndef PHYS_OFFSET
  83. #define PHYS_OFFSET         (CONFIG_DRAM_BASE)
  84. #endif
  85.  
  86. #ifndef END_MEM
  87. #define END_MEM             (CONFIG_DRAM_BASE + CONFIG_DRAM_SIZE)
  88. #endif
  89.  
  90. #ifndef PAGE_OFFSET
  91. #define PAGE_OFFSET        (PHYS_OFFSET)
  92. #endif
  93.  
  94. /*
  95.  * The module can be at any place in ram in nommu mode.
  96.  */
  97. #define MODULES_END        (END_MEM)
  98. #define MODULES_VADDR        (PHYS_OFFSET)
  99.  
  100. #endif /* !CONFIG_MMU */
  101.  
  102. /*
  103.  * Size of DMA-consistent memory region.  Must be multiple of 2M,
  104.  * between 2MB and 14MB inclusive.
  105.  */
  106. #ifndef CONSISTENT_DMA_SIZE
  107. #define CONSISTENT_DMA_SIZE SZ_2M
  108. #endif
  109.  
  110. /*
  111.  * Physical vs virtual RAM address space conversion.  These are
  112.  * private definitions which should NOT be used outside memory.h
  113.  * files.  Use virt_to_phys/phys_to_virt/__pa/__va instead.
  114.  */
  115. #ifndef __virt_to_phys
  116. #define __virt_to_phys(x)    ((x) - PAGE_OFFSET + PHYS_OFFSET)
  117. #define __phys_to_virt(x)    ((x) - PHYS_OFFSET + PAGE_OFFSET)
  118. #endif
  119.  
  120. /*
  121.  * Convert a physical address to a Page Frame Number and back
  122.  */
  123. #define    __phys_to_pfn(paddr)    ((paddr) >> PAGE_SHIFT)
  124. #define    __pfn_to_phys(pfn)    ((pfn) << PAGE_SHIFT)
  125.  
  126. #ifndef __ASSEMBLY__
  127.  
  128. /*
  129.  * The DMA mask corresponding to the maximum bus address allocatable
  130.  * using GFP_DMA.  The default here places no restriction on DMA
  131.  * allocations.  This must be the smallest DMA mask in the system,
  132.  * so a successful GFP_DMA allocation will always satisfy this.
  133.  */
  134. #ifndef ISA_DMA_THRESHOLD
  135. #define ISA_DMA_THRESHOLD    (0xffffffffULL)
  136. #endif
  137.  
  138. #ifndef arch_adjust_zones
  139. #define arch_adjust_zones(node,size,holes) do { } while (0)
  140. #elif !defined(CONFIG_ZONE_DMA)
  141. #error "custom arch_adjust_zones() requires CONFIG_ZONE_DMA"
  142. #endif
  143.  
  144. /*
  145.  * PFNs are used to describe any physical page; this means
  146.  * PFN 0 == physical address 0.
  147.  *
  148.  * This is the PFN of the first RAM page in the kernel
  149.  * direct-mapped view.  We assume this is the first page
  150.  * of RAM in the mem_map as well.
  151.  */
  152. #define PHYS_PFN_OFFSET    (PHYS_OFFSET >> PAGE_SHIFT)
  153.  
  154. /*
  155.  * These are *only* valid on the kernel direct mapped RAM memory.
  156.  * Note: Drivers should NOT use these.  They are the wrong
  157.  * translation for translating DMA addresses.  Use the driver
  158.  * DMA support - see dma-mapping.h.
  159.  */
  160. static inline unsigned long virt_to_phys(void *x)
  161. {
  162.     return __virt_to_phys((unsigned long)(x));
  163. }
  164.  
  165. static inline void *phys_to_virt(unsigned long x)
  166. {
  167.     return (void *)(__phys_to_virt((unsigned long)(x)));
  168. }
  169.  
  170. /*
  171.  * Drivers should NOT use these either.
  172.  */
  173. #define __pa(x)            __virt_to_phys((unsigned long)(x))
  174. #define __va(x)            ((void *)__phys_to_virt((unsigned long)(x)))
  175. #define pfn_to_kaddr(pfn)    __va((pfn) << PAGE_SHIFT)
  176.  
  177. /*
  178.  * Virtual <-> DMA view memory address translations
  179.  * Again, these are *only* valid on the kernel direct mapped RAM
  180.  * memory.  Use of these is *deprecated* (and that doesn't mean
  181.  * use the __ prefixed forms instead.)  See dma-mapping.h.
  182.  */
  183. static inline __deprecated unsigned long virt_to_bus(void *x)
  184. {
  185.     return __virt_to_bus((unsigned long)x);
  186. }
  187.  
  188. static inline __deprecated void *bus_to_virt(unsigned long x)
  189. {
  190.     return (void *)__bus_to_virt(x);
  191. }
  192.  
  193. /*
  194.  * Conversion between a struct page and a physical address.
  195.  *
  196.  * Note: when converting an unknown physical address to a
  197.  * struct page, the resulting pointer must be validated
  198.  * using VALID_PAGE().  It must return an invalid struct page
  199.  * for any physical address not corresponding to a system
  200.  * RAM address.
  201.  *
  202.  *  page_to_pfn(page)    convert a struct page * to a PFN number
  203.  *  pfn_to_page(pfn)    convert a _valid_ PFN number to struct page *
  204.  *  pfn_valid(pfn)    indicates whether a PFN number is valid
  205.  *
  206.  *  virt_to_page(k)    convert a _valid_ virtual address to struct page *
  207.  *  virt_addr_valid(k)    indicates whether a virtual address is valid
  208.  */
  209. #ifndef CONFIG_DISCONTIGMEM
  210.  
  211. #define ARCH_PFN_OFFSET        PHYS_PFN_OFFSET
  212.  
  213. #ifndef CONFIG_SPARSEMEM
  214. #define pfn_valid(pfn)        ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
  215. #endif
  216.  
  217. #define virt_to_page(kaddr)    pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
  218. #define virt_addr_valid(kaddr)    ((unsigned long)(kaddr) >= PAGE_OFFSET && (unsigned long)(kaddr) < (unsigned long)high_memory)
  219.  
  220. #define PHYS_TO_NID(addr)    (0)
  221.  
  222. #else /* CONFIG_DISCONTIGMEM */
  223.  
  224. /*
  225.  * This is more complex.  We have a set of mem_map arrays spread
  226.  * around in memory.
  227.  */
  228. #include <linux/numa.h>
  229.  
  230. #define arch_pfn_to_nid(pfn)    PFN_TO_NID(pfn)
  231. #define arch_local_page_offset(pfn, nid) LOCAL_MAP_NR((pfn) << PAGE_SHIFT)
  232.  
  233. #define pfn_valid(pfn)                        \
  234.     ({                            \
  235.         unsigned int nid = PFN_TO_NID(pfn);        \
  236.         int valid = nid < MAX_NUMNODES;            \
  237.         if (valid) {                    \
  238.             pg_data_t *node = NODE_DATA(nid);    \
  239.             valid = (pfn - node->node_start_pfn) <    \
  240.                 node->node_spanned_pages;    \
  241.         }                        \
  242.         valid;                        \
  243.     })
  244.  
  245. #define virt_to_page(kaddr)                    \
  246.     (ADDR_TO_MAPBASE(kaddr) + LOCAL_MAP_NR(kaddr))
  247.  
  248. #define virt_addr_valid(kaddr)    (KVADDR_TO_NID(kaddr) < MAX_NUMNODES)
  249.  
  250. /*
  251.  * Common discontigmem stuff.
  252.  *  PHYS_TO_NID is used by the ARM kernel/setup.c
  253.  */
  254. #define PHYS_TO_NID(addr)    PFN_TO_NID((addr) >> PAGE_SHIFT)
  255.  
  256. /*
  257.  * Given a kaddr, ADDR_TO_MAPBASE finds the owning node of the memory
  258.  * and returns the mem_map of that node.
  259.  */
  260. #define ADDR_TO_MAPBASE(kaddr)    NODE_MEM_MAP(KVADDR_TO_NID(kaddr))
  261.  
  262. /*
  263.  * Given a page frame number, find the owning node of the memory
  264.  * and returns the mem_map of that node.
  265.  */
  266. #define PFN_TO_MAPBASE(pfn)    NODE_MEM_MAP(PFN_TO_NID(pfn))
  267.  
  268. #ifdef NODE_MEM_SIZE_BITS
  269. #define NODE_MEM_SIZE_MASK    ((1 << NODE_MEM_SIZE_BITS) - 1)
  270.  
  271. /*
  272.  * Given a kernel address, find the home node of the underlying memory.
  273.  */
  274. #define KVADDR_TO_NID(addr) \
  275.     (((unsigned long)(addr) - PAGE_OFFSET) >> NODE_MEM_SIZE_BITS)
  276.  
  277. /*
  278.  * Given a page frame number, convert it to a node id.
  279.  */
  280. #define PFN_TO_NID(pfn) \
  281.     (((pfn) - PHYS_PFN_OFFSET) >> (NODE_MEM_SIZE_BITS - PAGE_SHIFT))
  282.  
  283. /*
  284.  * Given a kaddr, LOCAL_MEM_MAP finds the owning node of the memory
  285.  * and returns the index corresponding to the appropriate page in the
  286.  * node's mem_map.
  287.  */
  288. #define LOCAL_MAP_NR(addr) \
  289.     (((unsigned long)(addr) & NODE_MEM_SIZE_MASK) >> PAGE_SHIFT)
  290.  
  291. #endif /* NODE_MEM_SIZE_BITS */
  292.  
  293. #endif /* !CONFIG_DISCONTIGMEM */
  294.  
  295. /*
  296.  * For BIO.  "will die".  Kill me when bio_to_phys() and bvec_to_phys() die.
  297.  */
  298. #define page_to_phys(page)    (page_to_pfn(page) << PAGE_SHIFT)
  299.  
  300. /*
  301.  * Optional coherency support.  Currently used only by selected
  302.  * Intel XSC3-based systems.
  303.  */
  304. #ifndef arch_is_coherent
  305. #define arch_is_coherent()        0
  306. #endif
  307.  
  308. #endif
  309.  
  310. #include <asm-generic/memory_model.h>
  311.  
  312. #endif
  313.